////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-2017 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxsettingsmanager.h
/// @brief Declarations for the SettingsManager class.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXSETTINGSMANAGER_H
#define CAMXSETTINGSMANAGER_H

// Common CamX Includes
#include "camxdefs.h"
#include "camxtypes.h"

// Core CamX Includes
#include "camxoverridesettingsfile.h"
#include "g_camxsettings.h"

CAMX_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief SettingsManager class manages the set of default settings and override helpers.
///
/// More specifically:
///  1) Creates override helper objects (file, setprops)
///  2) Validates/overrides settings
///  3) Protects settings with Read/Write lock methods
///  4) Dumps current settings
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class SettingsManager
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Public Methods
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#if CAMX_USE_MEMSPY
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateNoSpy
    ///
    /// @brief  This function creates an instance of the SettingsManager class that is not tracked using MemSpy.
    ///
    /// @param  pStaticSettings A pointer to the static settings structure containing settings values. If NULL, SettingsManager
    ///                         will internally allocate a structure.
    ///
    /// @return An instance of the SettingsManager class
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static SettingsManager* CreateNoSpy(
        StaticSettings* pStaticSettings);
#endif // CAMX_USE_MEMSPY

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  This function creates an instance of the SettingsManager class.
    ///
    /// @param  pStaticSettings A pointer to the static settings structure containing settings values. If NULL, SettingsManager
    ///                         will internally allocate a structure.
    ///
    /// @return An instance of the SettingsManager class
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static SettingsManager* Create(
        StaticSettings* pStaticSettings);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destroy
    ///
    /// @brief  This function destroys the instance of the SettingsManager class.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID Destroy();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetStaticSettings
    ///
    /// @brief  Returns a pointer to the static settings structure to directly access all settings values.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CAMX_INLINE const StaticSettings* GetStaticSettings() const
    {
        return m_pStaticSettings;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateOverrideProperties
    ///
    /// @brief  Updates the override properties based on the currently set properties
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateOverrideProperties();

#if SETTINGS_DUMP_ENABLE
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DumpSettings
    ///
    /// @brief  This function prints all hardware-independent settings names and values in the settings store.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DumpSettings() const;
#endif // SETTINGS_DUMP_ENABLE

protected:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Protected Methods
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SettingsManager
    ///
    /// @brief  The private constructor for the SettingsManager object.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    SettingsManager();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~SettingsManager
    ///
    /// @brief  The private destructor for the SettingsManager object.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~SettingsManager();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Initialize
    ///
    /// @brief  Initializes the settings manager object.
    ///
    /// @param  pStaticSettings A pointer to the static settings structure containing settings values. If NULL, SettingsManager
    ///                         will internally allocate a structure.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult Initialize(
        StaticSettings* pStaticSettings);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwInitializeDefaultSettings
    ///
    /// @brief  Initializes all hardware-dependent, non-process-specific settings to default values. The implementation of this
    ///         method is auto-generated from the hardware-dependent settings XML file.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID HwInitializeDefaultSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwInitializeDefaultDebugSettings
    ///
    /// @brief  Initializes the hardware-dependent, process-specific settings specified under "Debug Settings" to default
    ///         values. The implementation of this method is auto-generated from the hardware-dependent settings XML file.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID HwInitializeDefaultDebugSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwLoadOverrideSettings
    ///
    /// @brief  Loads the hardware-dependent override settings from the specified store. The implementation of this method is
    ///         auto-generated from the hardware-dependent settings XML file.
    ///
    /// @param  pOverrideSettingsStore A pointer to the override settings store object from which to load override settings.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult HwLoadOverrideSettings(
        IOverrideSettingsStore* pOverrideSettingsStore);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwLoadOverrideProperties
    ///
    /// @brief  Loads the hardware-dependent override settings from the specified store. The implementation of this method is
    ///         auto-generated from the hardware-dependent settings XML file.
    ///
    /// @param  pOverrideSettingsStore A pointer to the override settings store object from which to load override settings.
    /// @param  updateStatic           TRUE means update both dynamic and non-dynamic settings
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult HwLoadOverrideProperties(
        IOverrideSettingsStore* pOverrideSettingsStore,
        BOOL                    updateStatic);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwValidateSettings
    ///
    /// @brief  Validates the current values in the hardware-dependent settings structures.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult HwValidateSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HwDumpSettings
    ///
    /// @brief  This function prints all hardware-dependent settings names and values in the settings store.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID HwDumpSettings() const;

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Private Methods
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// InitializeDefaultSettings
    ///
    /// @brief  Initializes all hardware-independent, non-process-specific settings to default values. The implementation of
    ///         this method is auto-generated from the hardware-independent settings XML file.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID InitializeDefaultSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// InitializeDefaultDebugSettings
    ///
    /// @brief  Initializes the hardware-independent, process-specific settings specified under "Debug Settings" to default
    ///         values. The implementation of this method is auto-generated from the hardware-independent settings XML file.
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID InitializeDefaultDebugSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LoadOverrideSettings
    ///
    /// @brief  Loads the hardware-independent override settings from the specified store. The implementation of this method is
    ///         auto-generated from the hardware-independent settings XML file.
    ///
    /// @param  pOverrideSettingsStore A pointer to the override settings store object from which to load override settings.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult LoadOverrideSettings(
        IOverrideSettingsStore* pOverrideSettingsStore);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// LoadOverrideProperties
    ///
    /// @brief  Loads the hardware-independent override settings from the specified store. The implementation of this method is
    ///         auto-generated from the hardware-independent settings XML file.
    ///
    /// @param  pOverrideSettingsStore A pointer to the override settings store object from which to load override settings.
    /// @param  updateStatic           TRUE means update both dynamic and non-dynamic settings
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult LoadOverrideProperties(
        IOverrideSettingsStore* pOverrideSettingsStore,
        BOOL                    updateStatic);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ValidateSettings
    ///
    /// @brief  Validates the current values in the hardware-independent settings structures.
    ///
    /// @return CamxResultSuccess if successful
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ValidateSettings();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateLogSettings
    ///
    /// @brief  Updates all log and trace utils with latest Settings
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateLogSettings();

    // Do not implement the copy constructor or assignment operator
    SettingsManager(const SettingsManager& rSettingsManager) = delete;
    SettingsManager& operator= (const SettingsManager& rRHS) = delete;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Private Member Data
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Flag to indicate whether the static settings struct was internally allocated
    BOOL m_internallyAllocatedStaticSettings;

    StaticSettings*         m_pStaticSettings;         ///< Pointer to the static settings structure
    IOverrideSettingsStore* m_pOverrideSettingsStore;  ///< Pointer to the settings store
};

CAMX_NAMESPACE_END

#endif // CAMXSETTINGSMANAGER_H
